CI: owner-finals (yas-run/yas#93) - #46

A WAIT's temporary look can be refused as CONFLICT because this session's own
look at the process is still bound: a concurrent CONTROL's, or a route that an
eviction failed and has yet to detach (dispatch_outbound fails the route, then
sends the Detach). Such a WAIT waited for the catalogue's next change, which a
Detach doesn't make, so it slept until the process ended and then found nothing
of an ordinary process: NOT_FOUND. It now waits with Manager::wait_native_look,
which also wakes when the record changes and returns once nothing refuses a look:
no exit in flight and no binding of this endpoint.

a_wait_that_finds_its_own_look_still_bound_answers_once_it_goes fails a watcher's
route, WAITs, and detaches the look 200 ms later. Without the change the WAIT
answered NOT_FOUND once the child's second had passed; with it, the exit.

The Exit arm's comment still said such a WAIT answers CONFLICT; it says what it
does now.

An ordinary process belongs to its spawning session. yas-client WAITs for its
exit when the attachment that would report it goes first: a stream reset or
dropped, a DETACH, or a connection that drops and comes back just as the process
exits. That WAIT answered NOT_FOUND whenever the exit came in between. With no
binding of the owner's to take the exit, the record was released and nothing was
kept, since only a detachable process's final is retained. The same happened in
two other cases. When the owner's route failed as the exit was queued, the
adapter dropped the exit because no route was there to take it. When the exit
found the owner's event queue full, it was dropped, and the attachment waited
for it forever.

The owner now finds the exit in each case:
- The adapter records the replay of every exit it is handed, whether its route
  is there or not. NativeEvent::Exit now carries the process handle for that.
- For the owner's endpoint alone, the native side keeps the final of an
  ordinary process whose exit that endpoint missed: it had no binding when the
  exit was queued, or its exit event was dropped before dispatch. WriterGuard
  now tells its action whether its event was dispatched. The endpoint keeps the
  newest exit_replays() of these finals, as many as the adapter keeps replays,
  until it shuts down. WATCH, and so WAIT and ATTACH, finds them after the
  public finals. They are stored before the release moves the catalogue, which
  is what a WAIT that found the exit on its way waits for.
- A binding whose exit can't be queued is evicted, as a binding that falls
  behind is. Its attachment fails and its client WAITs, instead of waiting for
  an exit that won't come.

New tests, each of which failed with NotFound before this change:
- an_owner_whose_look_went_before_the_exit_still_waits_for_it
- an_owner_whose_route_failed_as_the_exit_came_still_waits_for_it
- an_owner_whose_queue_was_full_as_the_exit_came_still_finds_it

an_owner_that_drops_its_stream_after_the_exit_still_waits_for_it no longer
depends on whether its detach comes before or after the exit.

a_watcher_whose_queue_fills_after_the_exit_fails_alone assumed that 80 lines
make 80 frames, which breaks when a loaded reader takes several lines in one
read. Its child now writes each line only after the test has received the last
one, as a FIFO tells it, and runs without stdin, so there are no stdin events.
The test checks each frame, and checks that only the watcher's attachment
failed, evicted.